package com.hanlin.beforejavacodesummary.yanshi;

import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import org.apache.poi.xwpf.usermodel.*;

import java.io.*;
import java.util.Map;

public class XWPFTemplateCleaner {
    
    /**
     * 编译模板、渲染数据并删除空行
     */
    public static void renderAndClean(String sourceFile, Map<String, Object> map, 
                                    String outputPath, Configure configure) throws IOException {
        // 编译和渲染模板
        XWPFTemplate template = XWPFTemplate.compile(sourceFile, configure).render(map);
        
        // 获取渲染后的文档
        XWPFDocument document = template.getXWPFDocument();
        
        // 删除空行
        removeEmptyLines(document);
        
        // 输出到文件
        try (FileOutputStream out = new FileOutputStream(outputPath)) {
            document.write(out);
        }
        
        template.close();
    }
    
    /**
     * 删除文档中的空行
     */
    private static void removeEmptyLines(XWPFDocument document) {
        // 删除空段落
        removeEmptyParagraphs(document);
        
        // 删除空表格
        removeEmptyTables(document);
    }
    
    /**
     * 删除空段落
     */
    private static void removeEmptyParagraphs(XWPFDocument document) {
        // 使用倒序删除避免位置变化问题
        for (int i = document.getParagraphs().size() - 1; i >= 0; i--) {
            XWPFParagraph paragraph = document.getParagraphs().get(i);
            if (isEmptyParagraph(paragraph)) {
                int pos = document.getPosOfParagraph(paragraph);
                if (pos != -1) {
                    document.removeBodyElement(pos);
                }
            }
        }
    }
    
    /**
     * 删除空表格（没有图片且没有内容的表格）
     */
    private static void removeEmptyTables(XWPFDocument document) {
        // 使用倒序删除避免位置变化问题
        for (int i = document.getTables().size() - 1; i >= 0; i--) {
            XWPFTable table = document.getTables().get(i);
            if (isEmptyTable(table)) {
                int pos = document.getPosOfTable(table);
                if (pos != -1) {
                    document.removeBodyElement(pos);
                }
            }
        }
    }
    
    /**
     * 判断表格是否为空（没有图片且没有有效内容）
     */
    private static boolean isEmptyTable(XWPFTable table) {
        if (table == null) return true;
        
        // 检查表格中是否有图片
        if (hasImageInTable(table)) {
            return false; // 有图片，保留表格
        }
        
        // 检查表格中是否有有效内容
        for (XWPFTableRow row : table.getRows()) {
            for (XWPFTableCell cell : row.getTableCells()) {
                // 检查单元格文本
                String cellText = cell.getText();
                if (cellText != null && !cellText.trim().isEmpty()) {
                    return false; // 有文本内容，保留表格
                }
                
                // 检查单元格内的段落
                for (XWPFParagraph paragraph : cell.getParagraphs()) {
                    if (!isEmptyParagraph(paragraph)) {
                        return false; // 有段落内容，保留表格
                    }
                }
            }
        }
        
        return true; // 没有图片也没有有效内容，删除表格
    }
    
    /**
     * 判断表格中是否包含图片
     */
    private static boolean hasImageInTable(XWPFTable table) {
        if (table == null) return false;
        
        for (XWPFTableRow row : table.getRows()) {
            for (XWPFTableCell cell : row.getTableCells()) {
                if (hasImageInTableCell(cell)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    /**
     * 判断表格单元格中是否包含图片
     */
    private static boolean hasImageInTableCell(XWPFTableCell cell) {
        if (cell == null) return false;
        
        // 检查单元格内的所有段落
        for (XWPFParagraph paragraph : cell.getParagraphs()) {
            if (hasImageInParagraph(paragraph)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 判断段落中是否包含图片
     */
    private static boolean hasImageInParagraph(XWPFParagraph paragraph) {
        if (paragraph == null) return false;
        
        for (XWPFRun run : paragraph.getRuns()) {
            if (hasImageInRun(run)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 判断Run中是否包含图片
     */
    private static boolean hasImageInRun(XWPFRun run) {
        if (run == null) return false;
        
        // 方法1: 检查嵌入式图片
        if (!run.getEmbeddedPictures().isEmpty()) {
            return true;
        }
        
        // 方法2: 检查CTDrawing（更可靠的方法）
        if (run.getCTR().getDrawingList().size() > 0) {
            return true;
        }
        
        // 方法3: 检查所有XML子元素
        if (run.getCTR().sizeOfDrawingArray() > 0) {
            return true;
        }
        
        return false;
    }
    
    /**
     * 判断段落是否为空
     */
    private static boolean isEmptyParagraph(XWPFParagraph paragraph) {
        if (paragraph == null) return true;
        
        String text = paragraph.getText();
        if (text != null && !text.trim().isEmpty()) {
            return false;
        }
        
        // 检查所有文本运行
        for (XWPFRun run : paragraph.getRuns()) {
            String runText = run.getText(0);
            if (runText != null && !runText.trim().isEmpty()) {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * 判断表格行是否为空（保留此方法用于其他可能的用途）
     */
    private static boolean isEmptyTableRow(XWPFTableRow row) {
        for (XWPFTableCell cell : row.getTableCells()) {
            // 检查单元格文本
            String cellText = cell.getText();
            if (cellText != null && !cellText.trim().isEmpty()) {
                return false;
            }
            
            // 检查单元格内的段落
            for (XWPFParagraph paragraph : cell.getParagraphs()) {
                if (!isEmptyParagraph(paragraph)) {
                    return false;
                }
            }
            
            // 检查单元格内是否有图片
            if (hasImageInTableCell(cell)) {
                return false;
            }
        }
        return true;
    }
}